package service

import (
	"context"
	"encoding/json"
	"fmt"
	"log"
	"strconv"
	"strings"
	"sync"
	"time"

	"gitee.com/wangshh_123/cross-pay-go/src/database"
	"gitee.com/wangshh_123/cross-pay-go/src/models"
	"gitee.com/wangshh_123/cross-pay-go/src/platform/providers/hlPay"
	hlpayModels "gitee.com/wangshh_123/cross-pay-go/src/platform/providers/hlPay/models"
	"gitee.com/wangshh_123/cross-pay-go/src/platform/providers/hlPay/services"
	"gitee.com/wangshh_123/cross-pay-go/src/utils/common/i18n"

	"github.com/redis/go-redis/v9"
	"gorm.io/gorm"
)

// HlPayTransactionCacheService HlPay交易数据缓存服务
type HlPayTransactionCacheService struct {
	hlpayClient *hlPay.HlPayClient
	redisClient *redis.Client
	db          *gorm.DB
	cacheMutex  sync.RWMutex

	// 配置参数
	cacheExpiration time.Duration // 缓存过期时间，默认1分钟
	syncInterval    time.Duration // 同步间隔，默认120秒
	daysToSync      int           // 同步天数，默认3天
}

// HlPayCachedTransaction 缓存的HlPay交易记录
type HlPayCachedTransaction struct {
	ID                  string `json:"id"`
	ClientTransactionId string `json:"clientTransactionId"`
	Company             string `json:"company"`
	CardId              string `json:"cardId"`
	CardNo              string `json:"cardNo"`
	TransactionNo       string `json:"transactionNo"`
	TransactionType     string `json:"transactionType"`
	Currency            string `json:"currency"`
	Amount              string `json:"amount"`
	TransactionAmount   string `json:"transactionAmount"`
	TransactionCurrency string `json:"transactionCurrency"`
	Fee                 string `json:"fee"`
	Status              string `json:"status"`
	TransactionTime     string `json:"transactionTime"`
	Detail              string `json:"detail"`
	Remark              string `json:"remark"`
	CreateTime          string `json:"createTime"`
	UserID              int64  `json:"user_id,omitempty"`
	CardNickname        string `json:"card_nickname,omitempty"`
}

// CacheConfig 缓存配置
type CacheConfig struct {
	Expiration   time.Duration `json:"expiration"`    // 缓存过期时间
	SyncInterval time.Duration `json:"sync_interval"` // 同步间隔
	DaysToSync   int           `json:"days_to_sync"`  // 同步天数
}

// NewHlPayTransactionCacheService 创建HlPay交易缓存服务
func NewHlPayTransactionCacheService(hlpayClient *hlPay.HlPayClient, config *CacheConfig) *HlPayTransactionCacheService {
	service := &HlPayTransactionCacheService{
		hlpayClient: hlpayClient,
		redisClient: database.RedisClient,
		db:          database.DB,
	}

	// 设置默认配置
	if config != nil {
		service.cacheExpiration = config.Expiration
		service.syncInterval = config.SyncInterval
		service.daysToSync = config.DaysToSync
	} else {
		// 默认配置
		service.cacheExpiration = 1 * time.Minute // 1分钟过期
		service.syncInterval = 120 * time.Second  // 120秒同步间隔
		service.daysToSync = 10                   // 10天数据
	}

	return service
}

// SyncRecentTransactions 同步最近的交易数据
func (s *HlPayTransactionCacheService) SyncRecentTransactions(ctx context.Context) (*CacheResult, error) {
	s.cacheMutex.Lock()
	defer s.cacheMutex.Unlock()

	log.Printf("🔄 [HlPay缓存服务] 开始同步交易数据...")

	result := &CacheResult{
		UserStats: make(map[int64]UserCacheStats),
	}

	// 计算时间范围
	endTime := time.Now()
	startTime := endTime.AddDate(0, 0, -s.daysToSync)

	log.Printf("📅 [HlPay缓存服务] 同步时间范围: %s 到 %s", startTime.Format("2006-01-02 15:04:05"), endTime.Format("2006-01-02 15:04:05"))

	// 获取所有交易数据
	transactions, err := s.fetchAllTransactions(ctx, startTime.Format("2006-01-02 15:04:05"), endTime.Format("2006-01-02 15:04:05"))
	if err != nil {
		log.Printf("❌ [HlPay缓存服务] 获取交易数据失败: %v", err)
		return nil, fmt.Errorf("获取交易数据失败: %v", err)
	}

	log.Printf("📊 [HlPay缓存服务] 从HlPay API获取到 %d 条交易记录", len(transactions))

	// 批量处理交易数据
	if err := s.processTransactionsBatch(ctx, transactions, result); err != nil {
		log.Printf("❌ [HlPay缓存服务] 处理交易数据失败: %v", err)
		return nil, fmt.Errorf("处理交易数据失败: %v", err)
	}

	log.Printf("✅ [HlPay缓存服务] 同步完成，新增记录: %d", result.NewRecords)
	return result, nil
}

// fetchAllTransactions 获取所有交易记录
func (s *HlPayTransactionCacheService) fetchAllTransactions(ctx context.Context, beginTime, endTime string) ([]hlpayModels.CardTransactionDetailRow, error) {
	var allTransactions []hlpayModels.CardTransactionDetailRow
	pageSize := 1000
	pageIndex := 1

	for {
		params := &hlpayModels.CardTransactionDetailRequest{
			BeginTime: beginTime,
			EndTime:   endTime,
		}

		response, err := services.GetCardTransactionDetail(ctx, s.hlpayClient, params)
		if err != nil {
			return nil, fmt.Errorf("获取第 %d 页交易记录失败: %v", pageIndex, err)
		}

		if response.Code != 200 {
			return nil, fmt.Errorf("API返回错误，错误码: %d, 错误信息: %s", response.Code, response.Msg)
		}

		allTransactions = append(allTransactions, response.Rows...)
		log.Printf("[HlPayTransactionCache] 获取第 %d 页，记录数: %d", pageIndex, len(response.Rows))

		// 如果返回的记录数少于页面大小，说明已经获取完所有数据
		if len(response.Rows) < pageSize {
			break
		}

		pageIndex++
	}

	return allTransactions, nil
}

// processTransactionsBatch 批量处理交易记录
func (s *HlPayTransactionCacheService) processTransactionsBatch(ctx context.Context, transactions []hlpayModels.CardTransactionDetailRow, result *CacheResult) error {
	// 预热卡片用户映射缓存
	cardUserMap, err := s.getCardUserMapping(ctx)
	if err != nil {
		return fmt.Errorf("获取卡片用户映射失败: %v", err)
	}

	// 批量获取卡片昵称映射
	cardNicknameMap, err := s.getCardNicknameMapping(ctx, transactions)
	if err != nil {
		log.Printf("⚠️ [HlPay缓存服务] 获取卡片昵称映射失败: %v", err)
		// 不中断处理，继续执行
	}

	// 使用Pipeline批量处理
	pipe := s.redisClient.Pipeline()

	for _, transaction := range transactions {
		// 转换为缓存格式（传入昵称映射）
		cachedTx := s.convertToCachedTransaction(transaction, cardUserMap, cardNicknameMap)

		// 设置交易记录缓存
		txKey := fmt.Sprintf("hlpay_transaction:%s", cachedTx.ID)
		txData, _ := json.Marshal(cachedTx)
		pipe.Set(ctx, txKey, txData, s.cacheExpiration)

		// 添加到卡片交易列表
		cardTxListKey := fmt.Sprintf("hlpay_card_transactions:%s", cachedTx.CardId)
		pipe.ZAdd(ctx, cardTxListKey, redis.Z{
			Score:  float64(time.Now().Unix()),
			Member: cachedTx.ID,
		})
		pipe.Expire(ctx, cardTxListKey, s.cacheExpiration)

		// 如果有用户ID，添加到用户交易列表
		if cachedTx.UserID > 0 {
			userTxListKey := fmt.Sprintf("hlpay_user_transactions:%d", cachedTx.UserID)
			pipe.ZAdd(ctx, userTxListKey, redis.Z{
				Score:  float64(time.Now().Unix()),
				Member: cachedTx.ID,
			})
			pipe.Expire(ctx, userTxListKey, s.cacheExpiration)

			// 更新用户统计
			s.updateUserStats(result, cachedTx)
		}

		// 添加到全局交易列表
		globalTxListKey := "hlpay_global_transactions"
		pipe.ZAdd(ctx, globalTxListKey, redis.Z{
			Score:  float64(time.Now().Unix()),
			Member: cachedTx.ID,
		})
		pipe.Expire(ctx, globalTxListKey, s.cacheExpiration)
	}

	// 执行批量操作
	_, err = pipe.Exec(ctx)
	if err != nil {
		return fmt.Errorf("批量缓存操作失败: %v", err)
	}

	result.NewRecords = len(transactions)
	return nil
}

// convertToCachedTransaction 转换为缓存交易记录
func (s *HlPayTransactionCacheService) convertToCachedTransaction(tx hlpayModels.CardTransactionDetailRow, cardUserMap map[string]int64, cardNicknameMap map[string]string) *HlPayCachedTransaction {
	cachedTx := &HlPayCachedTransaction{
		ID:                  fmt.Sprintf("%v", tx.ID),
		ClientTransactionId: tx.ClientTransactionId,
		Company:             tx.Company,
		CardId:              tx.CardId,
		CardNo:              tx.CardNo,
		TransactionType:     tx.TransactionType,
		Currency:            tx.Currency,
		Amount:              tx.Amount,
		Status:              tx.Status,
		TransactionTime:     tx.TransactionTime,
		Remark:              tx.Remark,
		CreateTime:          tx.CreateTime,
	}

	// 设置可选字段
	if tx.TransactionNo != nil {
		cachedTx.TransactionNo = *tx.TransactionNo
	}
	if tx.TransactionAmount != nil {
		cachedTx.TransactionAmount = *tx.TransactionAmount
	}
	if tx.TransactionCurrency != nil {
		cachedTx.TransactionCurrency = *tx.TransactionCurrency
	}
	if tx.Detail != nil {
		cachedTx.Detail = *tx.Detail
	}

	// 设置用户ID和卡片昵称
	if userID, exists := cardUserMap[tx.CardId]; exists {
		cachedTx.UserID = userID
		// 从批量获取的昵称映射中获取卡片昵称
		if cardNickname, exists := cardNicknameMap[tx.CardId]; exists {
			cachedTx.CardNickname = cardNickname
		}
	}

	return cachedTx
}

// GetCardUserMapping 获取卡片用户映射（公共方法）
func (s *HlPayTransactionCacheService) GetCardUserMapping(ctx context.Context) (map[string]int64, error) {
	return s.getCardUserMapping(ctx)
}

// getCardUserMapping 获取卡片用户映射
func (s *HlPayTransactionCacheService) getCardUserMapping(ctx context.Context) (map[string]int64, error) {
	// 先从Redis缓存获取
	cacheKey := "hlpay_card_user_mapping"
	cachedData, err := s.redisClient.Get(ctx, cacheKey).Result()
	if err == nil {
		var mapping map[string]int64
		if json.Unmarshal([]byte(cachedData), &mapping) == nil {
			return mapping, nil
		}
	}

	// 从数据库获取
	var userCards []models.UserCard
	if err := s.db.Select("card_id, user_id").Find(&userCards).Error; err != nil {
		return nil, fmt.Errorf("查询用户卡片失败: %v", err)
	}

	mapping := make(map[string]int64)
	for _, userCard := range userCards {
		mapping[userCard.CardID] = userCard.UserID
	}

	// 缓存到Redis，30分钟过期
	if mappingData, err := json.Marshal(mapping); err == nil {
		s.redisClient.Set(ctx, cacheKey, mappingData, 30*time.Minute)
	}

	return mapping, nil
}

// getCardNicknameMapping 批量获取卡片昵称映射
func (s *HlPayTransactionCacheService) getCardNicknameMapping(ctx context.Context, transactions []hlpayModels.CardTransactionDetailRow) (map[string]string, error) {
	// 收集所有唯一的卡片ID
	cardIDs := make(map[string]bool)
	for _, tx := range transactions {
		cardIDs[tx.CardId] = true
	}

	// 转换为切片
	var cardIDList []string
	for cardID := range cardIDs {
		cardIDList = append(cardIDList, cardID)
	}

	if len(cardIDList) == 0 {
		return make(map[string]string), nil
	}

	// 批量查询数据库
	var userCards []models.UserCard
	if err := s.db.Where("card_id IN ?", cardIDList).Select("card_id, nike_name").Find(&userCards).Error; err != nil {
		return nil, fmt.Errorf("批量查询卡片昵称失败: %v", err)
	}

	// 构建映射
	nicknameMap := make(map[string]string)
	for _, userCard := range userCards {
		nicknameMap[userCard.CardID] = userCard.NikeName
	}

	log.Printf("📊 [HlPay缓存服务] 批量获取到 %d 个卡片的昵称映射", len(nicknameMap))
	return nicknameMap, nil
}

// getCardNicknameByCardID 根据卡片ID获取卡片昵称（保留用于兼容性）
func (s *HlPayTransactionCacheService) getCardNicknameByCardID(cardID string) (string, error) {
	var userCard models.UserCard
	if err := s.db.Where("card_id = ?", cardID).Select("nike_name").First(&userCard).Error; err != nil {
		return "", err
	}
	return userCard.NikeName, nil
}

// batchGetTransactions 批量获取交易详情（优化Redis查询）
func (s *HlPayTransactionCacheService) batchGetTransactions(ctx context.Context, txIDs []string) ([]*HlPayCachedTransaction, error) {
	if len(txIDs) == 0 {
		return []*HlPayCachedTransaction{}, nil
	}

	pipe := s.redisClient.Pipeline()
	cmds := make([]*redis.StringCmd, len(txIDs))

	// 批量获取
	for i, txID := range txIDs {
		txKey := fmt.Sprintf("hlpay_transaction:%s", txID)
		cmds[i] = pipe.Get(ctx, txKey)
	}

	// 执行Pipeline
	_, err := pipe.Exec(ctx)
	if err != nil && err != redis.Nil {
		return nil, fmt.Errorf("批量获取交易详情失败: %v", err)
	}

	// 处理结果
	var transactions []*HlPayCachedTransaction
	for i, cmd := range cmds {
		txData, err := cmd.Result()
		if err != nil {
			log.Printf("⚠️ [HlPay缓存服务] 获取交易 %s 详情失败: %v", txIDs[i], err)
			continue
		}

		var tx HlPayCachedTransaction
		if json.Unmarshal([]byte(txData), &tx) == nil {
			transactions = append(transactions, &tx)
		} else {
			log.Printf("❌ [HlPay缓存服务] 解析交易 %s 数据失败", txIDs[i])
		}
	}

	return transactions, nil
}

// updateUserStats 更新用户统计
func (s *HlPayTransactionCacheService) updateUserStats(result *CacheResult, tx *HlPayCachedTransaction) {
	if tx.UserID <= 0 {
		return
	}

	amount, _ := strconv.ParseFloat(tx.Amount, 64)

	if stats, exists := result.UserStats[tx.UserID]; exists {
		stats.TransactionCount++
		stats.TotalAmount += amount
		result.UserStats[tx.UserID] = stats
	} else {
		result.UserStats[tx.UserID] = UserCacheStats{
			UserID:           tx.UserID,
			TransactionCount: 1,
			TotalAmount:      amount,
			Currency:         tx.Currency,
		}
	}
}

// GetUserTransactionsWithPagination 获取用户交易记录（带分页）
func (s *HlPayTransactionCacheService) GetUserTransactionsWithPagination(ctx context.Context, userID int64, page, pageSize int, typeParam, statusParam, nickname string) ([]*HlPayCachedTransaction, int64, error) {
	if page <= 0 {
		page = 1
	}
	if pageSize <= 0 {
		pageSize = 20
	}

	log.Printf("🔍 [HlPay缓存服务] 开始获取用户 %d 的交易记录，页码: %d, 页面大小: %d, type: %s, status: %s, nickname: %s", userID, page, pageSize, typeParam, statusParam, nickname)

	// 获取用户交易ID列表
	userTxListKey := fmt.Sprintf("hlpay_user_transactions:%d", userID)
	log.Printf("🗝️ [HlPay缓存服务] 查询Redis键: %s", userTxListKey)

	// 获取总数
	total, err := s.redisClient.ZCard(ctx, userTxListKey).Result()
	if err != nil {
		log.Printf("❌ [HlPay缓存服务] 获取用户交易总数失败: %v", err)
		return nil, 0, fmt.Errorf("获取用户交易总数失败: %v", err)
	}

	log.Printf("📊 [HlPay缓存服务] 用户 %d 总交易数: %d", userID, total)

	// 计算分页范围
	start := int64((page - 1) * pageSize)
	stop := start + int64(pageSize) - 1

	// 获取当前页的交易ID列表
	txIDs, err := s.redisClient.ZRevRange(ctx, userTxListKey, start, stop).Result()
	if err != nil {
		log.Printf("❌ [HlPay缓存服务] 获取用户交易ID列表失败: %v", err)
		return nil, 0, fmt.Errorf("获取用户交易ID列表失败: %v", err)
	}

	log.Printf("📋 [HlPay缓存服务] 从Redis获取到 %d 个交易ID (范围: %d-%d)", len(txIDs), start, stop)

	// 获取语言参数
	var shouldTranslate bool
	var lang string
	if l := ctx.Value("language"); l != nil {
		if langStr, ok := l.(string); ok && langStr != "" {
			lang = strings.ToUpper(langStr) // 统一使用大写
			shouldTranslate = true
			log.Printf("🔤 [HlPay缓存服务] 检测到语言参数: %s, 将进行翻译", lang)
		}
	}
	if !shouldTranslate {
		lang = "EN" // 默认英文，使用大写
		log.Printf("🔤 [HlPay缓存服务] 未检测到语言参数，将返回原始英文值")
	}

	// 前端到后端映射表
	var typeMap = map[string]string{
		"auth":            "Consumption",
		"recharge":        "TransferIn",
		"recharge_return": "TransferOut",
		"verification":    "Credit",
		"refund":          "Refund",
		"void":            "Reversal",
	}
	var statusMap = map[string]string{
		"pending":    "Waiting",
		"processing": "Pending",
		"succeed":    "Closed",
		"failed":     "Fail",
	}
	mappedType := ""
	if typeParam != "" {
		mappedType = typeMap[typeParam]
	}
	mappedStatus := ""
	if statusParam != "" {
		mappedStatus = statusMap[statusParam]
	}

	// 卡昵称过滤：如有nickname参数，查出该用户下所有匹配昵称的卡片ID集合
	var nicknameCardIDSet map[string]struct{}
	if nickname != "" {
		var userCards []models.UserCard
		err := s.db.Where("user_id = ? AND platform = ? AND nike_name LIKE ?", userID, "hlpay", "%"+nickname+"%").Find(&userCards).Error
		if err != nil {
			log.Printf("❌ [HlPay缓存服务] 查询用户卡片昵称失败: %v", err)
			return nil, 0, fmt.Errorf("查询用户卡片昵称失败: %v", err)
		}
		nicknameCardIDSet = make(map[string]struct{})
		for _, card := range userCards {
			nicknameCardIDSet[card.CardID] = struct{}{}
		}
		log.Printf("[HlPay缓存服务] 用户 %d 匹配昵称 '%s' 的卡片数: %d", userID, nickname, len(nicknameCardIDSet))
		if len(nicknameCardIDSet) == 0 {
			return []*HlPayCachedTransaction{}, 0, nil
		}
	}

	// 翻译函数
	translateStatus := func(status string) string {
		if !shouldTranslate {
			return status
		}
		switch strings.ToLower(status) {
		case "waiting":
			return i18n.Messages["hlpay_status_waiting"].Get(lang)
		case "pending":
			return i18n.Messages["hlpay_status_pending"].Get(lang)
		case "closed":
			return i18n.Messages["hlpay_status_closed"].Get(lang)
		case "failed":
			return i18n.Messages["hlpay_status_failed"].Get(lang)
		default:
			return status
		}
	}
	translateType := func(tp string) string {
		if !shouldTranslate {
			return tp
		}
		switch strings.ToLower(tp) {
		case "consumption":
			return i18n.Messages["hlpay_transaction_type_consumption"].Get(lang)
		case "transferin":
			return i18n.Messages["hlpay_transaction_type_transfer_in"].Get(lang)
		case "transferout":
			return i18n.Messages["hlpay_transaction_type_transfer_out"].Get(lang)
		case "credit":
			return i18n.Messages["hlpay_transaction_type_credit"].Get(lang)
		case "refund":
			return i18n.Messages["hlpay_transaction_type_refund"].Get(lang)
		case "reversal":
			return i18n.Messages["hlpay_transaction_type_reversal"].Get(lang)
		default:
			return tp
		}
	}

	// 批量获取交易详情
	var transactions []*HlPayCachedTransaction
	for i, txID := range txIDs {
		txKey := fmt.Sprintf("hlpay_transaction:%s", txID)
		txData, err := s.redisClient.Get(ctx, txKey).Result()
		if err != nil {
			log.Printf("⚠️ [HlPay缓存服务] 获取交易 %s 详情失败: %v", txID, err)
			continue
		}

		var tx HlPayCachedTransaction
		if json.Unmarshal([]byte(txData), &tx) == nil {
			// 筛选逻辑：如有type/status参数，需匹配
			if mappedType != "" && tx.TransactionType != mappedType {
				continue
			}
			if mappedStatus != "" && tx.Status != mappedStatus {
				continue
			}
			// 卡昵称过滤
			if nickname != "" && nicknameCardIDSet != nil {
				if _, ok := nicknameCardIDSet[tx.CardId]; !ok {
					continue
				}
			}
			tx.Status = translateStatus(tx.Status)
			tx.TransactionType = translateType(tx.TransactionType)
			transactions = append(transactions, &tx)
			log.Printf("✅ [HlPay缓存服务] 成功解析交易 %d: ID=%s, 卡片=%s", i+1, tx.ID, tx.CardId)
		} else {
			log.Printf("❌ [HlPay缓存服务] 解析交易 %s 数据失败", txID)
		}
	}

	// 重新计算total（筛选后实际数量）
	totalFiltered := int64(len(transactions))

	log.Printf("📈 [HlPay缓存服务] 最终返回 %d 条交易记录，总数: %d", len(transactions), totalFiltered)
	return transactions, totalFiltered, nil
}

// GetCardTransactionsWithPagination 获取卡片交易记录（带分页）
func (s *HlPayTransactionCacheService) GetCardTransactionsWithPagination(ctx context.Context, cardID string, page, pageSize int) ([]*HlPayCachedTransaction, int64, error) {
	if page <= 0 {
		page = 1
	}
	if pageSize <= 0 {
		pageSize = 20
	}
	if pageSize > 100 {
		pageSize = 100
	}

	log.Printf("🔍 [HlPay缓存服务] 开始获取卡片 %s 的交易记录，页码: %d, 页面大小: %d", cardID, page, pageSize)

	// 获取语言参数
	var shouldTranslate bool
	var lang string
	if l := ctx.Value("language"); l != nil {
		if langStr, ok := l.(string); ok && langStr != "" {
			lang = strings.ToUpper(langStr) // 统一使用大写
			shouldTranslate = true
			log.Printf("🔤 [HlPay缓存服务] 检测到语言参数: %s, 将进行翻译", lang)
		}
	}
	if !shouldTranslate {
		lang = "EN" // 默认英文，使用大写
		log.Printf("🔤 [HlPay缓存服务] 未检测到语言参数，将返回原始英文值")
	}

	// 翻译函数
	translateStatus := func(status string) string {
		if !shouldTranslate {
			return status
		}
		switch strings.ToLower(status) {
		case "waiting":
			return i18n.Messages["hlpay_status_waiting"].Get(lang)
		case "pending":
			return i18n.Messages["hlpay_status_pending"].Get(lang)
		case "closed":
			return i18n.Messages["hlpay_status_closed"].Get(lang)
		case "failed":
			return i18n.Messages["hlpay_status_failed"].Get(lang)
		default:
			return status
		}
	}

	translateType := func(transactionType string) string {
		if !shouldTranslate {
			return transactionType
		}
		switch strings.ToLower(transactionType) {
		case "consumption":
			return i18n.Messages["hlpay_transaction_type_consumption"].Get(lang)
		case "transferin":
			return i18n.Messages["hlpay_transaction_type_transfer_in"].Get(lang)
		case "transferout":
			return i18n.Messages["hlpay_transaction_type_transfer_out"].Get(lang)
		case "credit":
			return i18n.Messages["hlpay_transaction_type_credit"].Get(lang)
		case "refund":
			return i18n.Messages["hlpay_transaction_type_refund"].Get(lang)
		case "reversal":
			return i18n.Messages["hlpay_transaction_type_reversal"].Get(lang)
		default:
			return transactionType
		}
	}

	// 获取卡片交易ID列表
	cardTxListKey := fmt.Sprintf("hlpay_card_transactions:%s", cardID)
	log.Printf("🗝️ [HlPay缓存服务] 查询Redis键: %s", cardTxListKey)

	// 获取总数
	total, err := s.redisClient.ZCard(ctx, cardTxListKey).Result()
	if err != nil {
		log.Printf("❌ [HlPay缓存服务] 获取卡片交易总数失败: %v", err)
		return nil, 0, fmt.Errorf("获取卡片交易总数失败: %v", err)
	}

	log.Printf("📊 [HlPay缓存服务] 卡片 %s 总交易数: %d", cardID, total)

	// 计算分页范围
	start := int64((page - 1) * pageSize)
	stop := start + int64(pageSize) - 1

	// 获取当前页的交易ID列表
	txIDs, err := s.redisClient.ZRevRange(ctx, cardTxListKey, start, stop).Result()
	if err != nil {
		log.Printf("❌ [HlPay缓存服务] 获取卡片交易ID列表失败: %v", err)
		return nil, 0, fmt.Errorf("获取卡片交易ID列表失败: %v", err)
	}

	log.Printf("📋 [HlPay缓存服务] 从Redis获取到 %d 个交易ID (范围: %d-%d)", len(txIDs), start, stop)

	// 批量获取交易详情
	var transactions []*HlPayCachedTransaction
	for i, txID := range txIDs {
		txKey := fmt.Sprintf("hlpay_transaction:%s", txID)
		txData, err := s.redisClient.Get(ctx, txKey).Result()
		if err != nil {
			log.Printf("⚠️ [HlPay缓存服务] 获取交易 %s 详情失败: %v", txID, err)
			continue
		}

		var tx HlPayCachedTransaction
		if json.Unmarshal([]byte(txData), &tx) == nil {
			// 翻译状态和交易类型
			tx.Status = translateStatus(tx.Status)
			tx.TransactionType = translateType(tx.TransactionType)

			transactions = append(transactions, &tx)
			log.Printf("✅ [HlPay缓存服务] 成功解析交易 %d: ID=%s, 卡片=%s", i+1, tx.ID, tx.CardId)
		} else {
			log.Printf("❌ [HlPay缓存服务] 解析交易 %s 数据失败", txID)
		}
	}

	log.Printf("📈 [HlPay缓存服务] 最终返回 %d 条交易记录，总数: %d", len(transactions), total)
	return transactions, total, nil
}

// GetUserTransactions 获取用户交易记录（保持向后兼容）
func (s *HlPayTransactionCacheService) GetUserTransactions(ctx context.Context, userID int64, limit int) ([]*HlPayCachedTransaction, error) {
	if limit <= 0 {
		limit = 50
	}

	log.Printf("🔍 [HlPay缓存服务] 开始获取用户 %d 的交易记录，限制: %d", userID, limit)

	// 获取用户交易ID列表
	userTxListKey := fmt.Sprintf("hlpay_user_transactions:%d", userID)
	log.Printf("🗝️ [HlPay缓存服务] 查询Redis键: %s", userTxListKey)

	txIDs, err := s.redisClient.ZRevRange(ctx, userTxListKey, 0, int64(limit-1)).Result()
	if err != nil {
		log.Printf("❌ [HlPay缓存服务] 获取用户交易ID列表失败: %v", err)
		return nil, fmt.Errorf("获取用户交易ID列表失败: %v", err)
	}

	log.Printf("📋 [HlPay缓存服务] 从Redis获取到 %d 个交易ID", len(txIDs))

	// 批量获取交易详情
	var transactions []*HlPayCachedTransaction
	for i, txID := range txIDs {
		txKey := fmt.Sprintf("hlpay_transaction:%s", txID)
		txData, err := s.redisClient.Get(ctx, txKey).Result()
		if err != nil {
			log.Printf("⚠️ [HlPay缓存服务] 获取交易 %s 详情失败: %v", txID, err)
			continue
		}

		var tx HlPayCachedTransaction
		if json.Unmarshal([]byte(txData), &tx) == nil {
			transactions = append(transactions, &tx)
			log.Printf("✅ [HlPay缓存服务] 成功解析交易 %d: ID=%s, 卡片=%s", i+1, tx.ID, tx.CardId)
		} else {
			log.Printf("❌ [HlPay缓存服务] 解析交易 %s 数据失败", txID)
		}
	}

	log.Printf("📈 [HlPay缓存服务] 最终返回 %d 条交易记录", len(transactions))
	return transactions, nil
}

// GetCardTransactions 获取卡片交易记录（保持向后兼容）
func (s *HlPayTransactionCacheService) GetCardTransactions(ctx context.Context, cardID string, limit int) ([]*HlPayCachedTransaction, error) {
	if limit <= 0 {
		limit = 50
	}

	log.Printf("🔍 [HlPay缓存服务] 开始获取卡片 %s 的交易记录，限制: %d", cardID, limit)

	// 获取卡片交易ID列表
	cardTxListKey := fmt.Sprintf("hlpay_card_transactions:%s", cardID)
	log.Printf("🗝️ [HlPay缓存服务] 查询Redis键: %s", cardTxListKey)

	txIDs, err := s.redisClient.ZRevRange(ctx, cardTxListKey, 0, int64(limit-1)).Result()
	if err != nil {
		log.Printf("❌ [HlPay缓存服务] 获取卡片交易ID列表失败: %v", err)
		return nil, fmt.Errorf("获取卡片交易ID列表失败: %v", err)
	}

	log.Printf("📋 [HlPay缓存服务] 从Redis获取到 %d 个交易ID", len(txIDs))

	// 批量获取交易详情
	var transactions []*HlPayCachedTransaction
	for i, txID := range txIDs {
		txKey := fmt.Sprintf("hlpay_transaction:%s", txID)
		txData, err := s.redisClient.Get(ctx, txKey).Result()
		if err != nil {
			log.Printf("⚠️ [HlPay缓存服务] 获取交易 %s 详情失败: %v", txID, err)
			continue
		}

		var tx HlPayCachedTransaction
		if json.Unmarshal([]byte(txData), &tx) == nil {
			transactions = append(transactions, &tx)
			log.Printf("✅ [HlPay缓存服务] 成功解析交易 %d: ID=%s, 卡片=%s", i+1, tx.ID, tx.CardId)
		} else {
			log.Printf("❌ [HlPay缓存服务] 解析交易 %s 数据失败", txID)
		}
	}

	log.Printf("📈 [HlPay缓存服务] 最终返回 %d 条交易记录", len(transactions))
	return transactions, nil
}

// GetTransactionByID 根据ID获取交易记录
func (s *HlPayTransactionCacheService) GetTransactionByID(ctx context.Context, txID string) (*HlPayCachedTransaction, error) {
	txKey := fmt.Sprintf("hlpay_transaction:%s", txID)
	txData, err := s.redisClient.Get(ctx, txKey).Result()
	if err == redis.Nil {
		// 缓存未命中，自动同步
		s.SyncRecentTransactions(ctx)
		txData, err = s.redisClient.Get(ctx, txKey).Result()
	}
	if err != nil {
		return nil, fmt.Errorf("交易记录不存在: %v", err)
	}
	var tx HlPayCachedTransaction
	if err := json.Unmarshal([]byte(txData), &tx); err != nil {
		return nil, fmt.Errorf("解析交易记录失败: %v", err)
	}

	// 获取语言参数并处理国际化
	var shouldTranslate bool
	var lang string
	if l := ctx.Value("language"); l != nil {
		if langStr, ok := l.(string); ok && langStr != "" {
			lang = strings.ToUpper(langStr) // 统一使用大写
			shouldTranslate = true
			log.Printf("🔤 [HlPay缓存服务] 检测到语言参数: %s, 将进行翻译", lang)
		}
	}
	if !shouldTranslate {
		lang = "EN" // 默认英文，使用大写
		log.Printf("🔤 [HlPay缓存服务] 未检测到语言参数，将返回原始英文值")
	}

	// 翻译函数
	translateStatus := func(status string) string {
		if !shouldTranslate {
			return status
		}
		switch strings.ToLower(status) {
		case "waiting":
			return i18n.Messages["hlpay_status_waiting"].Get(lang)
		case "pending":
			return i18n.Messages["hlpay_status_pending"].Get(lang)
		case "closed":
			return i18n.Messages["hlpay_status_closed"].Get(lang)
		case "failed":
			return i18n.Messages["hlpay_status_failed"].Get(lang)
		default:
			return status
		}
	}
	translateType := func(tp string) string {
		if !shouldTranslate {
			return tp
		}
		switch strings.ToLower(tp) {
		case "consumption":
			return i18n.Messages["hlpay_transaction_type_consumption"].Get(lang)
		case "transferin":
			return i18n.Messages["hlpay_transaction_type_transfer_in"].Get(lang)
		case "transferout":
			return i18n.Messages["hlpay_transaction_type_transfer_out"].Get(lang)
		case "credit":
			return i18n.Messages["hlpay_transaction_type_credit"].Get(lang)
		case "refund":
			return i18n.Messages["hlpay_transaction_type_refund"].Get(lang)
		case "reversal":
			return i18n.Messages["hlpay_transaction_type_reversal"].Get(lang)
		default:
			return tp
		}
	}

	// 应用翻译
	tx.Status = translateStatus(tx.Status)
	tx.TransactionType = translateType(tx.TransactionType)

	return &tx, nil
}

// GetTransactionByClientTransactionID 根据 clientTransactionId 获取交易记录
func (s *HlPayTransactionCacheService) GetTransactionByClientTransactionID(ctx context.Context, clientTxID string) (*HlPayCachedTransaction, error) {
	if clientTxID == "" {
		return nil, fmt.Errorf("clientTransactionId 不能为空")
	}

	pattern := "hlpay_transaction:*"
	keys, err := s.redisClient.Keys(ctx, pattern).Result()
	if err != nil || len(keys) == 0 {
		// 缓存未命中，自动同步
		s.SyncRecentTransactions(ctx)
		keys, err = s.redisClient.Keys(ctx, pattern).Result()
		if err != nil {
			return nil, fmt.Errorf("查询交易记录失败: %v", err)
		}
	}

	for _, key := range keys {
		txData, err := s.redisClient.Get(ctx, key).Result()
		if err != nil {
			continue
		}
		var tx HlPayCachedTransaction
		if json.Unmarshal([]byte(txData), &tx) == nil {
			if tx.ClientTransactionId == clientTxID {
				// 获取语言参数并处理国际化
				var shouldTranslate bool
				var lang string
				if l := ctx.Value("language"); l != nil {
					if langStr, ok := l.(string); ok && langStr != "" {
						lang = strings.ToUpper(langStr) // 统一使用大写
						shouldTranslate = true
						log.Printf("🔤 [HlPay缓存服务] 检测到语言参数: %s, 将进行翻译", lang)
					}
				}
				if !shouldTranslate {
					lang = "EN" // 默认英文，使用大写
					log.Printf("🔤 [HlPay缓存服务] 未检测到语言参数，将返回原始英文值")
				}

				// 翻译函数
				translateStatus := func(status string) string {
					if !shouldTranslate {
						return status
					}
					switch strings.ToLower(status) {
					case "waiting":
						return i18n.Messages["hlpay_status_waiting"].Get(lang)
					case "pending":
						return i18n.Messages["hlpay_status_pending"].Get(lang)
					case "closed":
						return i18n.Messages["hlpay_status_closed"].Get(lang)
					case "failed":
						return i18n.Messages["hlpay_status_failed"].Get(lang)
					default:
						return status
					}
				}
				translateType := func(tp string) string {
					if !shouldTranslate {
						return tp
					}
					switch strings.ToLower(tp) {
					case "consumption":
						return i18n.Messages["hlpay_transaction_type_consumption"].Get(lang)
					case "transferin":
						return i18n.Messages["hlpay_transaction_type_transfer_in"].Get(lang)
					case "transferout":
						return i18n.Messages["hlpay_transaction_type_transfer_out"].Get(lang)
					case "credit":
						return i18n.Messages["hlpay_transaction_type_credit"].Get(lang)
					case "refund":
						return i18n.Messages["hlpay_transaction_type_refund"].Get(lang)
					case "reversal":
						return i18n.Messages["hlpay_transaction_type_reversal"].Get(lang)
					default:
						return tp
					}
				}

				// 应用翻译
				tx.Status = translateStatus(tx.Status)
				tx.TransactionType = translateType(tx.TransactionType)

				return &tx, nil
			}
		}
	}

	return nil, fmt.Errorf("未找到指定 clientTransactionId 的交易记录")
}

// GetCacheStats 获取缓存统计信息
func (s *HlPayTransactionCacheService) GetCacheStats(ctx context.Context) (map[string]interface{}, error) {
	stats := make(map[string]interface{})

	// 获取全局交易数量
	globalCount, err := s.redisClient.ZCard(ctx, "hlpay_global_transactions").Result()
	if err == nil {
		stats["global_transaction_count"] = globalCount
	}

	// 获取最后同步时间
	lastSync, err := s.redisClient.Get(ctx, "hlpay_transaction_cache:last_sync").Result()
	if err == nil {
		stats["last_sync_time"] = lastSync
	}

	// 获取缓存键数量
	keys, err := s.redisClient.Keys(ctx, "hlpay_transaction:*").Result()
	if err == nil {
		stats["cached_transaction_count"] = len(keys)
	}

	// 添加配置信息
	stats["cache_expiration"] = s.cacheExpiration.String()
	stats["sync_interval"] = s.syncInterval.String()
	stats["days_to_sync"] = s.daysToSync

	return stats, nil
}

// ClearCache 清理缓存
func (s *HlPayTransactionCacheService) ClearCache(ctx context.Context) error {
	// 删除所有HlPay交易相关缓存
	patterns := []string{
		"hlpay_transaction:*",
		"hlpay_card_transactions:*",
		"hlpay_user_transactions:*",
		"hlpay_global_transactions",
		"hlpay_transaction_cache:*",
		"hlpay_card_user_mapping",
	}

	for _, pattern := range patterns {
		keys, err := s.redisClient.Keys(ctx, pattern).Result()
		if err != nil {
			continue
		}
		if len(keys) > 0 {
			s.redisClient.Del(ctx, keys...)
		}
	}

	log.Printf("[HlPayTransactionCache] 缓存清理完成")
	return nil
}

// UpdateConfig 更新配置
func (s *HlPayTransactionCacheService) UpdateConfig(config *CacheConfig) {
	s.cacheMutex.Lock()
	defer s.cacheMutex.Unlock()

	if config.Expiration > 0 {
		s.cacheExpiration = config.Expiration
	}
	if config.SyncInterval > 0 {
		s.syncInterval = config.SyncInterval
	}
	if config.DaysToSync > 0 {
		s.daysToSync = config.DaysToSync
	}

	log.Printf("[HlPayTransactionCache] 配置已更新: 过期时间=%v, 同步间隔=%v, 同步天数=%d",
		s.cacheExpiration, s.syncInterval, s.daysToSync)
}

// GetConfig 获取当前配置
func (s *HlPayTransactionCacheService) GetConfig() *CacheConfig {
	s.cacheMutex.RLock()
	defer s.cacheMutex.RUnlock()

	return &CacheConfig{
		Expiration:   s.cacheExpiration,
		SyncInterval: s.syncInterval,
		DaysToSync:   s.daysToSync,
	}
}

// GetTransactionsByNicknameWithPagination 根据卡昵称查询交易记录（带分页）
func (s *HlPayTransactionCacheService) GetTransactionsByNicknameWithPagination(ctx context.Context, nickname string, page, pageSize int) ([]*HlPayCachedTransaction, int64, error) {
	if page <= 0 {
		page = 1
	}
	if pageSize <= 0 {
		pageSize = 20
	}
	if pageSize > 100 {
		pageSize = 100
	}

	log.Printf("🔍 [HlPay缓存服务] 开始根据卡昵称 %s 查询交易记录，页码: %d, 页面大小: %d", nickname, page, pageSize)

	// 步骤1: 根据昵称查询卡片ID
	var userCards []models.UserCard
	if err := s.db.Where("nike_name LIKE ? AND platform = ?", "%"+nickname+"%", "hlpay").Find(&userCards).Error; err != nil {
		log.Printf("❌ [HlPay缓存服务] 根据昵称查询卡片失败: %v", err)
		return nil, 0, fmt.Errorf("根据昵称查询卡片失败: %v", err)
	}

	log.Printf("📊 [HlPay缓存服务] 找到 %d 张匹配昵称的卡片", len(userCards))

	if len(userCards) == 0 {
		log.Printf("⚠️ [HlPay缓存服务] 未找到匹配昵称的卡片")
		return []*HlPayCachedTransaction{}, 0, nil
	}

	// 步骤2: 收集所有卡片的交易ID
	var allTxIDs []string
	cardIDSet := make(map[string]bool)

	for _, card := range userCards {
		cardIDSet[card.CardID] = true
		log.Printf("💳 [HlPay缓存服务] 匹配卡片: ID=%s, 昵称=%s", card.CardID, card.NikeName)
	}

	// 从Redis获取所有匹配卡片的交易ID
	for cardID := range cardIDSet {
		cardTxListKey := fmt.Sprintf("hlpay_card_transactions:%s", cardID)
		txIDs, err := s.redisClient.ZRange(ctx, cardTxListKey, 0, -1).Result()
		if err != nil {
			log.Printf("⚠️ [HlPay缓存服务] 获取卡片 %s 交易ID失败: %v", cardID, err)
			continue
		}
		allTxIDs = append(allTxIDs, txIDs...)
		log.Printf("📋 [HlPay缓存服务] 卡片 %s 有 %d 条交易记录", cardID, len(txIDs))
	}

	// 去重并排序（按时间倒序）
	txIDMap := make(map[string]bool)
	var uniqueTxIDs []string
	for _, txID := range allTxIDs {
		if !txIDMap[txID] {
			txIDMap[txID] = true
			uniqueTxIDs = append(uniqueTxIDs, txID)
		}
	}

	total := int64(len(uniqueTxIDs))
	log.Printf("📊 [HlPay缓存服务] 去重后总交易数: %d", total)

	// 步骤3: 分页处理
	start := (page - 1) * pageSize
	end := start + pageSize
	if end > len(uniqueTxIDs) {
		end = len(uniqueTxIDs)
	}

	if start >= len(uniqueTxIDs) {
		log.Printf("⚠️ [HlPay缓存服务] 页码超出范围")
		return []*HlPayCachedTransaction{}, total, nil
	}

	pageTxIDs := uniqueTxIDs[start:end]
	log.Printf("📋 [HlPay缓存服务] 当前页交易ID数量: %d (范围: %d-%d)", len(pageTxIDs), start, end-1)

	// 步骤4: 批量获取交易详情
	var transactions []*HlPayCachedTransaction
	for i, txID := range pageTxIDs {
		txKey := fmt.Sprintf("hlpay_transaction:%s", txID)
		txData, err := s.redisClient.Get(ctx, txKey).Result()
		if err != nil {
			log.Printf("⚠️ [HlPay缓存服务] 获取交易 %s 详情失败: %v", txID, err)
			continue
		}

		var tx HlPayCachedTransaction
		if json.Unmarshal([]byte(txData), &tx) == nil {
			transactions = append(transactions, &tx)
			log.Printf("✅ [HlPay缓存服务] 成功解析交易 %d: ID=%s, 卡片=%s", i+1, tx.ID, tx.CardId)
		} else {
			log.Printf("❌ [HlPay缓存服务] 解析交易 %s 数据失败", txID)
		}
	}

	log.Printf("📈 [HlPay缓存服务] 最终返回 %d 条交易记录，总数: %d", len(transactions), total)
	return transactions, total, nil
}
